/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package fr.eisti.icc.zk;

import fr.eisti.icc.client.ClientBibliotheque;
import com.sun.jersey.api.client.UniformInterfaceException;
import fr.eisti.icc.data.Document;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.Reader;
import java.net.Authenticator;
import java.net.URL;
import java.net.URLConnection;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.codehaus.jettison.json.JSONArray;
import org.codehaus.jettison.json.JSONException;
import org.codehaus.jettison.json.JSONObject;
import org.zkoss.image.AImage;
import org.zkoss.util.media.Media;
import org.zkoss.zk.ui.Components;
import org.zkoss.zk.ui.Executions;
import org.zkoss.zk.ui.Session;
import org.zkoss.zk.ui.WrongValueException;
import org.zkoss.zk.ui.ext.AfterCompose;
import org.zkoss.zul.Combobox;
import org.zkoss.zul.Hlayout;
import org.zkoss.zul.Image;
import org.zkoss.zul.Label;
import org.zkoss.zul.Messagebox;
import org.zkoss.zul.Radio;
import org.zkoss.zul.Row;
import org.zkoss.zul.Slider;
import org.zkoss.zul.Textbox;
import proxy.HttpAuthenticateProxy;

/**
 *
 * @author rogers
 */
public class RechercheInfosLivre extends Hlayout implements AfterCompose {
    
    
    private Combobox sujet;
    private Textbox titre;
    private Textbox isbn;
    private Textbox auteurs;
    private Textbox editeur;
    private Textbox annee;
    private Textbox prix;
    private Textbox resume;
    private Textbox motsCles;
    private Textbox version;
    private Textbox systems;
    private Textbox memoire;
    private Textbox espace;
    private Label etat;
    private Slider sliderEtat;
    private List<String> lautheur = new ArrayList<String>();
    private Radio consultableTous;
    private Image lienImage;
    private Media media;
    private Session session;
    private Combobox selectionItem;
    private Row sujetGeneral;
    private Row rowIsbn;
    private Row rowTitre;
    private Row rowAuteurs;
    private Row rowEditeur;
    private Row rowMotCles;
    private Row rowAnnee;
    private Row rowPrix;
    private Row rowEtat;
    private Row rowConsultable;
    private Row rowResume;
    private Row rowValider;
    private Row rowVersion;
    private Row rowSystems;
    private Row rowMemoire;
    private Row rowEspace;
    private List<Row> listObligatoire;
    private List<Row> listLivre;
    private List<Row> listLogiciels;
    
    // this.docsALireAvant = new ArrayList<Document>();
    
    
    public void afterCompose() {
        Components.wireVariables(this, this);
        Components.addForwards(this, this);
        listObligatoire = new ArrayList() {
            { add(sujetGeneral); add(rowTitre); add(rowAuteurs);
            add(rowEditeur); add(rowMotCles); add(rowAnnee); add(rowPrix);
            add(rowEtat); add(rowConsultable); add(rowResume); add(rowValider); }};
        listLivre = new ArrayList() {
            { add(rowIsbn); }};
        listLogiciels = new ArrayList() {
            { add(rowVersion); add(rowSystems); add(rowMemoire); add(rowEspace); }};
    }
    
    private static String readAll(Reader rd) throws IOException {
        StringBuilder sb = new StringBuilder();
        int cp;
        while ((cp = rd.read()) != -1) {
            sb.append((char) cp);
        }
        return sb.toString();
    }
    
    private static JSONObject readJsonFromUrl(String url) throws IOException, JSONException {
        InputStream is = new URL(url).openStream();
        try {
            BufferedReader rd = new BufferedReader(new InputStreamReader(is, Charset.forName("UTF-8")));
            String jsonText = readAll(rd);
            JSONObject json = new JSONObject(jsonText);
            return json;
        } finally {
            is.close();
        }
    }
    
    public void onClick$lancerRecherche() throws IOException, JSONException {
        
        String url = "https://www.googleapis.com/books/v1/volumes?q=isbn:";
        String isbnValue = isbn.getValue();
        
        // Configurer et activer le proxy
        System.getProperties().put("proxySet","true");
        System.getProperties().put("proxyHost","proxy.pau.eisti.fr");
        System.getProperties().put("proxyPort","3128");
        
        // Rajoutez également la ligne suivante pour vous authentifier auprès du proxy :
        session=Executions.getCurrent().getSession();
        Authenticator.setDefault(
                new HttpAuthenticateProxy(session.getAttribute("user")+"",session.getAttribute("pass")+""));
        
        if (!isbnValue.equals("")) {
            
            JSONObject json = readJsonFromUrl(url+isbnValue);
            
            try {
                JSONArray items = json.getJSONArray("items");
                JSONObject volumeInfo = ((JSONObject) items.get(0)).getJSONObject("volumeInfo");
                
                /**
                 * String res = "";
                 *
                 * try {
                 * res += " subtitle : " + volumeInfo.get("subtitle") + "\n";
                 * }catch (JSONException jsone){};*/
                
                
                try {
                    titre.setValue(volumeInfo.getString("title"));
                    titre.invalidate();
                }catch (JSONException jsone){};
                
                try {
                    JSONArray authorsJSON = volumeInfo.getJSONArray("authors");
                    String s = "";
                    for (int i=0;i<authorsJSON.length()-1;i++) {
                        lautheur.add(authorsJSON.getString(i));
                        s += authorsJSON.getString(i)+", ";
                    }
                    lautheur.add(authorsJSON.getString(authorsJSON.length()-1));
                    s += authorsJSON.getString(authorsJSON.length()-1);
                    auteurs.setValue(s);
                    auteurs.invalidate();
                }catch (JSONException jsone){};
                
                try {
                    editeur.setValue(volumeInfo.getString("publisher"));
                    editeur.invalidate();
                }catch (JSONException jsone){};
                
                try {
                    annee.setValue(volumeInfo.getString("publishedDate"));
                    annee.invalidate();
                }catch (JSONException jsone){};
                
                try {
                    String src = volumeInfo.getJSONObject("imageLinks").getString("thumbnail");
                    lienImage.setSrc(src);
                    media = null;
                    lienImage.invalidate();
                }catch (JSONException jsone){};
                
            }catch (JSONException jsone){};
            
        }
    }
    
    public void onScroll$sliderEtat() {
        String e = "Mauvais";
        
        if (sliderEtat.getCurpos() >= 12 && sliderEtat.getCurpos() < 24) {
            e = "Moyen";
        }else if (sliderEtat.getCurpos() >= 24 && sliderEtat.getCurpos() < 36) {
            e = "Satisfaisant";
        }else if (sliderEtat.getCurpos() >= 36 && sliderEtat.getCurpos() < 48) {
            e = "Assez bon";
        }else if (sliderEtat.getCurpos() >= 48 && sliderEtat.getCurpos() < 60) {
            e = "Bon";
        }else if (sliderEtat.getCurpos() >= 60 && sliderEtat.getCurpos() < 72) {
            e = "Très bon";
        }else if (sliderEtat.getCurpos() >= 72 && sliderEtat.getCurpos() < 84) {
            e = "Comme neuf";
        }else if (sliderEtat.getCurpos() >= 84) {
            e = "Neuf";
        }
        
        etat.setValue(e);
        etat.invalidate();
    }
    
    public void onClick$validerLivre()
            throws UniformInterfaceException, InstantiationException, IllegalAccessException, IOException {
        
        
        // Remise à zéro du proxy
        System.getProperties().put("proxySet","false");
        System.getProperties().put("proxyHost","");
        System.getProperties().put("proxyPort","");
        
        // Rajoutez également la ligne suivante pour vous authentifier auprès du proxy :
        session=Executions.getCurrent().getSession();
        Authenticator.setDefault(new HttpAuthenticateProxy(session.getAttribute("user")+"",session.getAttribute("pass")+""));
        
        // Création du service
        ClientBibliotheque service = new ClientBibliotheque();
        
        // Liste des autheurs
        if (lautheur.isEmpty()) {
            String la[] = auteurs.getValue().split(", ");
            lautheur.addAll(Arrays.asList(la));
        }
        
        // Création du document
        Document doc = new Document(sujet.getSelectedItem().getLabel(),
                titre.getValue(), lautheur.get(0), Double.parseDouble(prix.getValue()),
                resume.getValue(), editeur.getValue(), annee.getValue(),
                sliderEtat.getCurpos(), isbn.getValue());
        
        // Ajout des auteurs
        for (int i=1; i<lautheur.size(); i++) {
            doc.addAutheur(lautheur.get(i));
        }
        
        // Disponibilité pour les élèves
        doc.setDisponiblePourEleve(consultableTous.isSelected());
        
        //Ajout type
        doc.setType(selectionItem.getSelectedItem().getLabel());
        
        //Ajout des mots clés
        String mots[] = motsCles.getValue().split(", ");
        for (String mot : mots) {
            System.out.println(mot);
            doc.addMotCle(mot);
        }
        
        // Ajout lien image
        String lien;
        if (media != null) {
            lien = sauverMedia(media);
        }else {
            lien = sauverUrl(lienImage.getSrc());
        }
        doc.setCheminImage(lien);
        
        boolean estLivre =
                selectionItem.getSelectedItem().getLabel().equals("Livres scolaires")
                || selectionItem.getSelectedItem().getLabel().equals("Livres classiques");
        
        if (estLivre) {
            
        }else if (selectionItem.getSelectedItem().getLabel().equals("Livres avec CD")) {
            
        }else if (selectionItem.getSelectedItem().getLabel().equals("Logiciels CDs")) {
            
        }else{
            
        }
        
        int status = service.addDocument_XML(doc).getStatus();
        
        if (status == 200) {
            Messagebox.show("Ajouté avec succès !!!");
            miseAJourChamps();
        }else{
            Messagebox.show("Erreur (code : "+status+" ) !!!");
        }
        
        service.close();
    }
    
    public void setMedia (Media m) {
        media = m;
        lienImage.setContent((AImage) m);
    }
    
    public void onChange$selectionItem () {
        
        boolean estLivre =
                selectionItem.getSelectedItem().getLabel().equals("Livres scolaires")
                || selectionItem.getSelectedItem().getLabel().equals("Livres classiques")
                || selectionItem.getSelectedItem().getLabel().equals("Livres avec CD");
        
        //rowPrix.setVisible(estLivre || selectionItem.getSelectedItem().getLabel().equals("Logiciels CDs"));
        
        for (Row row : listLogiciels) {
            row.setVisible(selectionItem.getSelectedItem().getLabel().equals("Logiciels CDs"));
        }
        
        for (Row row : listLivre) {
            row.setVisible(estLivre);
        }
        
        for (Row row : listObligatoire) {
            row.setVisible(true);
        }
    }
    
    public String sauverMedia(Media media) {
        
        if (!(media instanceof org.zkoss.image.Image)) {
            return null;
        }
        
        InputStream inStream = media.getStreamData();
        
        try {
            return upload(inStream);
        } catch (FileNotFoundException ex) {
            Messagebox.show(ex.getMessage());
        } catch (IOException ex) {
            Messagebox.show(ex.getMessage());
        }
        return null;
    }
    
    
    public String sauverUrl(String url) throws IOException {
        
        URLConnection connection = new URL(url).openConnection();
        java.io.InputStream inStream = connection.getInputStream();
        
        return upload(inStream);
    }
    
    
    public String upload(InputStream inStream) throws
            FileNotFoundException, IOException {
        
        String path = "/images/";
        
        // do {
        String fileName = (Math.random() * 1000000000) + ".png";
        File f = new File(path + fileName);
        // } while (!f.exists());
        
        
        OutputStream outStream = new FileOutputStream(new
                File(path + fileName));
        
        byte[] buffer = new byte[1024];
        
        int length;
        //copy the file content in bytes
        while ((length = inStream.read(buffer)) > 0) {
            outStream.write(buffer, 0, length);
        }
        
        inStream.close();
        outStream.close();
        
        Messagebox.show("file saved");
        
        return fileName;
    }
    
    
    
    
    private void miseAJourChamps() throws WrongValueException {
        sujet.setSelectedIndex(-1);
        titre.setValue("");
        isbn.setValue("");
        auteurs.setValue("");
        editeur.setValue("");
        annee.setValue("");
        prix.setValue("");
        resume.setValue("");
        sliderEtat.setCurpos(0);
        lienImage.setSrc("");
        motsCles.setValue("");
        media = null;
        
        for (Row row : listObligatoire) {
            row.setVisible(false);
        }
        
        for (Row row : listLivre) {
            row.setVisible(false);
        }
        
        for (Row row : listLogiciels) {
            row.setVisible(false);
        }
        
        selectionItem.setSelectedIndex(-1);
    }

}